unit ConnectP;

interface

const

// Diretório da DLL
DLL_SWEDA_CONNECT           = 'SWTECF.DLL';

// Opções de controle/janela
opMostrarJanela             = 0;
opOcultarJanela             = (1 shl 11);
opSegundoPlano              = (1 shl 12);
opMaximizarJanela           = 0;
opMinimizarJanela           = (1 shl 13);
opSemOpcaoCancelamento      = (1 shl 14);
opConfirmarInterrupcao      = (1 shl 15);

// Opções específicas das funções de captura
opSomenteText               = 0;            // Default
opWindowsCodePage           = 0;            // Default
opRichTextFormat            = (1 shl 0);
opCodePage860               = (1 shl 1);
opCapturar                  = (1 shl 2);
opGravar                    = ((1 shl 3) or opCapturar);
opAnexar                    = (1 shl 4);

// Opções da função de preenchimento de cheque
opChancela                  = (1 shl 0);
opCruzamento                = (1 shl 1);
opOrdemVersoFrente          = (1 shl 2);

// Opções da função de reconhecimento de caracteres magnéticos
opLeituraPreenchimento      = (1 shl 0);

// Opções da função de programação do ECF
opRedefinirParametrosECF    = (1 shl 0);
opConfigurarInterface       = (1 shl 1);
opEmitirListagemParametros  = (1 shl 2);
opConexao                   = (1 shl 3);

// Opções da função de autenticação
opSuprimirLogotipo          = (1 shl 0);


type

TItem = packed record
   Numero             : SmallInt;
   Codigo             : array [0..20] of Char;
   Quantidade         : array [0..10] of Char;
   Acrescimo          : array [0..21] of Char;
   Desconto           : array [0..21] of Char;
   Total              : array [0..21] of Char;
end;

TIFSCodigo = packed record
   Codigo             : SmallInt;
   Descricao          : PChar;
end;

TIFSEstado = packed record
     ZAtrasada,
     SemMovimento,
     GavetaAberta,
     PoucoPapel,
     FimPapel,
     ImpressoraEmErro,
     ChequeInserido,
     PreenchimentoChequePendente,
     MICRPendente                 : Boolean;
     FaseCupom                    : Word;
     JP1,
     MensagemImpressora,
     ChequePronto                 : Boolean;
     Reserva                      : array [0..19] of Char;
end;

// Logotipos
TLogotipoAutenticacao = packed record
   Arquivo                     : array [0..511] of Char;
   Texto                       : array [0..200] of Char;
end;

TLogotipoUsuario = packed record
    Arquivo        : array [0..511] of Char;
    Imagem         : packed record
       Bitmap      : array [0..143] of array [0..29] of Byte;
       Largura     : SmallInt;
       Altura      : SmallInt;
       CS          : Word;
    end;
end;

// TEF
TCCD = packed record
    Valor           : array [0..21] of Char;

    MP : packed record
        Indice      : Word;
        Denominacao : PChar;
    end;

    Parcelas    : Word;
    Parcela     : Word;
    CDC         : array [0..6] of Char;
    Via         : Word;
    Reimpresso  : Boolean;
    Estado      : Word;

    Vinculado   : packed record
       Tipo        : Word;
       COO         : array [0..6] of Char;
    end;
end;

TTEF = packed record
   NaoEmitido     : TCCD;
   NaoEstornado   : TCCD;
   Emitido        : TCCD;
   CCD            : array [0..15] of TCCD;
   Transacoes     : Word;
   Emitidos       : Word;
   NaoEmitidos    : Word;
   Estornados     : Word;
end;

TCoordenada = packed record
   X     : Word;
   Y     : Word;
end;

// Cheque
TIFSLeiauteCheque = packed record
   Codigo      : Word;
   Valor       : TCoordenada;
   Extenso     : array [0..1] of TCoordenada;
   Favorecido  : TCoordenada;
   Dia         : TCoordenada;
   ColunaAno   : SmallInt;
   Rodape      : TCoordenada;
   Largura     : SmallInt;
   DigitosAno  : SmallInt;
   Banco       : array [0..25] of Char;
   Origem      : Boolean;
end;

TCheque = packed record
   Favorecido     : array [0..80] of Char;
   Municipio      : array [0..50] of Char;
   Leiaute        : packed record
      Itens       : Word;
      Item        : array [1..100] of TIFSLeiauteCheque;
   end;
end;

TMICR = packed record
   Fonte          : Word;
   Opcoes         : Word;
   Timeout        : Integer;
   Resultado      : array [0..119] of Char;
   Erro           : TIFSCodigo;
end;

// Conjunto de contadores fiscais
TContadores = packed record
   CRO,
   CRZ,
   GNF,
   GRG,
   CCF,
   CFD,
   COO,
   CDC,
   NCN,
   NFC,
   CFC         : array[0..6] of Char;
   CON         : array [1..31] of array[0..6] of Char;
   CER         : array [1..31] of array[0..6] of Char;
end;

// Conjunto de totalizadores fiscais
TTotalizadores = packed record
   GT          : array[0..27] of Char;
   VB          : array[0..21] of Char;
   VLS         : array[0..21] of Char;
   VBS         : array[0..21] of Char;
   VLT         : array[0..21] of Char;
   VBT         : array[0..21] of Char;
   T           : array[1..16] of array[0..21] of Char;
   AT          : array[0..21] of Char;
   DT          : array[0..21] of Char;
   CT          : array[0..21] of Char;
   F           : array[1..3] of array[0..21] of Char;
   N           : array[1..3] of array[0..21] of Char;
   I           : array[1..3] of array[0..21] of Char;
   S           : array[1..16] of array[0..21] of Char;
   _AS          : array[0..21] of Char;
   DS          : array[0..21] of Char;
   CS          : array[0..21] of Char;
   FS          : array[1..3] of array[0..21] of Char;
   NS          : array[1..3] of array[0..21] of Char;
   _IS         : array[1..3] of array[0..21] of Char;
   VLNF        : array[0..21] of Char;
   VBNF        : array[0..21] of Char;
   DNF         : array[0..21] of Char;
   ANF         : array[0..21] of Char;
   CNF         : array[0..21] of Char;
   ONF         : array[1..31] of array[0..21] of Char;
   MP          : array[1..21] of array[0..21] of Char;
   Troco       : array[0..21] of Char;
end;

TFirmware = packed record
   Versao      : array[0..8] of Char;
   Data        : array[0..10] of Char;
   Horario     : array[0..9] of Char;
end;

TRelogio = packed record
   Data        : array[0..10] of Char;
   Horario     : array[0..9] of Char;
   Verao       : Boolean;
   Defeito     : TIFSCodigo;
end;

TFonte = packed record
   Altura    : Word;
   Largura   : Word;
end;

TImpressora = packed record
   Marca                      : array[0..12] of Char;
   Modelo                     : array[0..10] of Char;
   Tipo                       : array[0..10] of Char;
   Velocidade                 : Integer;
   DensidadeX                 : Word;
   DensidadeY                 : Word;
   Defeito                    : TIFSCodigo;
   AreaImpressao              : Word;

   ImprimeCodigoBarras,
   ImprimeUPCA,
   ImprimeUPCE,
   ImprimeEAN13,
   ImprimeEAN8,
   ImprimeCODE39,
   ImprimeITF,
   ImprimeCODEBAR,
   ImprimePDF417,

   ReconheceCaracterMagnetico,
   ReconheceCMC7,
   ReconheceE13B,

   Guilhotina,
   PreencheCheques,
   EndossaCheques,
   AutenticaDocumentos,
   ImprimeLogotipoUsuario     : Boolean;

   Fonte                      : array [0..7] of TFonte;
   FontePadrao                : TFonte;
end;

TCodificacaoGT = packed record
   Caracteres        : array [0..10] of Char;
   Data              : array [0..10] of Char;
   Horario           : array [0..9] of Char;
end;

TUsuario = packed record
   CNPJ              : array [0..20] of Char;
   IE                : array [0..20] of Char;
   IM                : array [0..20] of Char;
   SimboloMoeda      : array [0..4] of Char;
   Centavos          : Boolean;
   Numero            : Word;
   MFD               : packed record
      NumeroSerial   : array [0..20] of Char;
   end;
   GT                : array [0..27] of Char;
   CRO               : array [0..6] of Char;
   Gravacao          : packed record
      Data           : array [0..10] of Char;
      Horario        : array [0..9] of Char;
   end;
end;

TCliche = packed record
   RazaoSocial        : array [0..70] of Char;
   NomeFantasia       : array [0..70] of Char;
   Endereco           : array [0..280] of Char;
end;

TEquipamento = packed record
   Marca              : array [0..20] of Char;
   Modelo             : array [0..20] of Char;
   Tipo               : array [0..7] of Char;
   NumeroSerie        : array [0..21] of Char;
   SoftwareBasico     : TFirmware;
   Defeito            : TIFSCodigo;
end;


TMemoriaFiscal = packed record
   Versao              : array [0..3] of Char;
   NumeroSerial        : array [0..21] of Char;
   Berco               : Char;
   GTi                 : array [0..27] of Char;
   CROi                : array [0..6] of Char;
   CRZi                : array [0..6] of Char;
   Modelo              : array [0..20] of Char;
   Inicializacao       : packed record
      Data             : array [0..10] of Char;
      Horario          : array [0..9] of Char;
   end;
   MFD                 : packed record
      Itens            : Word;
      Item             : array[0..9] of packed record
         Usuario       : Word;
         NumeroSerial  : array[0..21] of Char;
         Data          : array[0..10] of Char;
         Horario       : array[0..9] of Char;
      end;
   end;

   SoftwareBasico      : packed record
      Itens            : Word;
      Item             : array [0..9] of TFirmware;
   end;

   CodificacaoGT       : packed record
      Itens            : Word;
      Item             : array [0..11] of TCodificacaoGT;
   end;

   Usuario             : packed record
      Itens            : Word;
      Item             : array [0..11] of TUsuario;
   end;
   Defeito             : TIFSCodigo;
end;


TMFD = packed record
   Versao              : array [0..3] of Char;
   NumeroSerial        : array [0..21] of Char;
   Data                : array [0..10] of Char;
   Horario             : array [0..9] of Char;
   ECF                 : packed record
      Modelo           : array [0..20] of Char;
      NumeroSerie      : array [0..21] of Char;
   end;
   CNPJ                : array [0..20] of Char;
   IE                  : array [0..20] of Char;
   IM                  : array [0..20] of Char;
   Instalacao          : packed record
      Data             : array [0..10] of Char;
      Horario          : array [0..9] of Char;
   end;
   Capacidade          : Integer;
   Consumo             : Integer;
   Defeito             : TIFSCodigo;
end;

TArquivoINI = packed record
      NSC                     : array [0..49] of Char;
      Terminal                : array [0..511] of Char;
      ArquivoOk               : Boolean;
      Log                     : array [0..301] of Char;
      Comunicacao             : packed record
         Porta                : Byte;
         Velocidade           : Byte;
      end;
      Caixa                   : array [0..10] of Char;
      NumeroSerie             : array [0..20] of Char;
      ArquivoConfiguracao     : array [0..511] of Char;
end;

///////////////////////////////////////////////////////////////////////////////
// Parametrização

// Indicadores
TIndicadores = packed record
   Operador       : array [0..49] of Char;
end;

// Lista de meios de pagamento
TListaMP = packed record
   Itens               : Word;
   Item                : array [1..21] of packed record
      Classificacao    : Byte;
      Denominacao      : array [0..20] of Char;
   end;
end;

// Lista de títulos para emissão de Relatório Gerencial
TListaRG = packed record
   Itens               : Word;
   Item                : array [1..31] of packed record
      Titulo           : array [0..25] of Char;
   end;
end;

// Lista de operações não fiscais
TListaONF = packed record
   Itens               : Word;
   Item                : array [1..31] of packed record
      Sinal            : Char;
      Denominacao      : array [0..20] of Char;
   end;
end;

// Lista de alíquotas
TListaAliquotas = packed record
   Itens               : Word;
   Item                : array [1..40] of array [0..7] of Char;
end;


// Conjunto de Parâmetros do ECF
TParametros = packed record
   CNPJ                    : array [0..20] of Char;
   IE                      : array [0..20] of Char;
   IM                      : array [0..20] of Char;
   SimboloMoeda            : array [0..4] of Char;
   Centavos                : Boolean;
   Cliche                  : TCliche;
   T                       : TListaAliquotas;
   S                       : TListaAliquotas;
   MP                      : TListaMP;
   ONF                     : TListaONF;
   RG                      : TListaRG;
   nF,
   nI,
   nN,
   nFS,
   nIS,
   nNS                     : Word;
   Loja                    : array [0..9] of Char;
   Caixa                   : array [0..9] of Char;
   CasaDecimalAdicional    : Boolean;
   DescontoISSQNHabilitado : Boolean;
   Moeda                   : array [0..1] of array [0..25] of Char;
   LogotipoUsuario         : TLogotipoUsuario;
   LogotipoAutenticacao    : TLogotipoAutenticacao;
   Cheque                  : TCheque;
   LegendaCNPJ             : array [0..10] of Char;
   LegendaIE               : array [0..10] of Char;
   LegendaIM               : array [0..10] of Char;
   CodificadoresGT         : array [0..10] of Char;
   RazaoSocial             : array [0..70] of Char;
   NomeFantasia            : array [0..70] of Char;
   Endereco                : array [0..280] of Char;
end;

///////////////////////////////////////////////////////////////////////////////
// Venda

TVenda = packed record
   Documento                : Word;                    
   Fase                     : Word;
   COO                      : array [0..6] of Char;
   VendaBruta               : array [0..21] of Char;
   Total                    : array [0..21] of Char;
   NaoRecebido              : array [0..21] of Char;
   Soma                     : array [0..21] of Char;
   Troco                    : array [0..21] of Char;

   UltimoItem               : packed record
      Numero                : Word;
      Codigo                : array [0..20] of Char;
      Quantidade            : array [0..10] of Char;
      Total                 : array [0..21] of Char;
   end;

   UltimoAcrescimo          : packed record
      Item                  : Word;
      Valor                 : array [0..21] of Char;
   end;

   UltimoDesconto           : packed record
      Item                  : Word;
      Valor                 : array [0..21] of Char;
   end;

   UltimoCancelamento       : packed record
      Item                  : Word;
   end;

   UltimoRecebimento        : packed record
      Classificacao         : Word;
      Indice                : Word;
      Valor                 : array [0..21] of Char;
      Meio                  : PChar;
   end;

   AcrescimoSubtotal        : array [0..21] of Char;
   DescontoSubtotal         : array [0..21] of Char;
   Acrescimos               : array [0..21] of Char;
   Descontos                : array [0..21] of Char;
   Cancelamentos            : array [0..21] of Char;

   Autenticacao             : packed record
      Valor                 : array [0..21] of Char;
      Percentual            : array [0..4] of Char;
      Numero                : Word;
      Origem                : Word;
      Operacao              : Word;
   end;

   MP                       : array [1..21] of packed record
      Total                 : array [0..21] of Char;
      Denominacao           : PChar;
   end;

   Itens                    : Word;
   Item                     : array [1..300] of TItem;
end;

TIFSMensagem = packed record
   Codigo             : SmallInt;
   Descricao          : PChar;
   Tipo               : Char;
   Sulfixo            : PChar;
   Dados              : PChar;
   Mensagem           : array [0..1199] of Char;
end;

TOperacao = packed record

   Comando            : packed record
      Numero          : Word;
      Proposito       : PChar;
      Sintaxe         : array[0..1200] of Char;
      Argumentos      : Pchar;
      Retorno         : array[0..1200] of Char;
   end;

   ID                 : Word;
   Descricao          : PChar;
   Sequencial         : Integer;
   Indeferida         : Boolean;
   ComandoTransmitido : Boolean;
   ErroInterno        : Boolean;
   Erro               : TIFSCodigo;
   Documento          : TIFSCodigo;
   Modo               : Word;
   Estado             : TIFSEstado;
end;




TECFSweda = packed record
   Estado                       : TIFSEstado;
   Mensagem                     : TIFSMensagem;
   Tarefa                       : TIFSCodigo;
   Documento                    : TIFSCodigo;
   Modo                         : Word;
   Operacional                  : Boolean;
   ConfiguracaoECF              : SmallInt;
   Controle                     : Char;
   Progresso                    : SmallInt;
   UltimaReducao,
   Movimento,
   UltimoReinicio,
   UltimoDocumento              : packed record
      Data                      : array[0..10] of Char;
      Horario                   : array[0..9] of Char;
   end;
   MICR                         : TMICR;
   DipSwitch                    : array [0..15] of Char;
   IDAplicativo                 : array [0..199] of Char;
   Indicadores                  : TIndicadores;
   MPProgramados,
   CapacidadeMP,
   ONFsProgramadas,
   CapacidadeONFs,
   RGsProgramados,
   CapacidadeRGs,
   AliquotasICMSProgramadas,
   CapacidadeAliquotasICMS,
   AliquotasISSQNProgramadas,
   CapacidadeAliquotasISSQN     : Word;
   SemUsuario,
   SemCliche,
   SemCodificacaoGT,
   SemCaixa,
   SemParametrosOperacionais    : Boolean;
   ProtocoloComandos            : Char;
   INI                          : TArquivoINI;
   Terminal                     : array [0..511] of Char;
   ArquivoInicializacao         : array [0..511] of Char;
   ArquivoConfiguracao          : array [0..511] of Char;
   ArquivoCFGPadrao             : Boolean;
   ECF                          : TEquipamento;
   MF                           : TMemoriaFiscal;
   MFD                          : TMFD;
   Relogio                      : TRelogio;
   Venda                        : TVenda;
   TEF                          : TTEF;
   Impressora                   : TImpressora;
   Contadores                   : TContadores;
   Totalizadores                : TTotalizadores;
   Parametros                   : TParametros;
   Operacao                     : TOperacao; 
end;




type PTECFSweda = ^TECFSweda;
TEventoMensagemC = procedure (ECF : PTECFSweda; Texto : PChar; Extensao : Word); stdcall;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 1. FUNÇÕES DE INICIALIZAÇÃO APLICAÇÃO/INTERFACE

function SWEDA_CriarInterface (Buffer : Pointer = nil; Size : Integer = 0; EventoMensagem : TEventoMensagemC = nil) : Boolean; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_ConectarECF (Opcao : Word = 0) : Boolean; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_ConectarAplicativo(Identificacao : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_ConectarAplicativo(Identificacao : String) : SmallInt; overload;
function SWEDA_DesconectarAplicativo() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_VersaoInterface : Word; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_IdentificarOperadorCaixa(Identificacao : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_IdentificarOperadorCaixa(Identificacao : String) : SmallInt; overload;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 2. FUNÇÕES PARA EMISSÃO DE DOCUMENTOS

// a. Cupom Fiscal
function SWEDA_AbrirCupomFiscal() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_RegistrarItem (Quantidade : PChar; Codigo : PChar; ValorUnitario : PChar; UnidadeMedida : PChar; SituacaoTributaria : PChar; Descricao : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_RegistrarItem (Quantidade : String; Codigo : String; ValorUnitario : String; UnidadeMedida : String; SituacaoTributaria : String; Descricao : String) : SmallInt; overload;
function SWEDA_EmitirCupomAdicional() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;

// b. Operações Não-Fiscais
function SWEDA_AbrirComprovanteNaoFiscal() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_RegistrarOperacaoNaoFiscal(Denominacao : PChar; Total : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_RegistrarOperacaoNaoFiscal(Denominacao : String; Total : String) : SmallInt; overload;

// c. Registros de venda (Cupom Fiscal ou Comprovante de Operações Não-Fiscais)
function SWEDA_RegistrarConsumidor(CNPJ : PChar = nil; Nome : PChar = nil; Endereco : PChar = nil; Rodape : Boolean = false) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_RegistrarConsumidor(CNPJ : String = ''; Nome : String = ''; Endereco : String = ''; Rodape : Boolean = false) : SmallInt; overload;
function SWEDA_AplicarAcrescimoSobreItem (ValorAcrescimo : PChar; Item : Word = 0) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_AplicarAcrescimoSobreItem (ValorAcrescimo : String; Item : Word = 0) : SmallInt; overload;
function SWEDA_AplicarDescontoSobreItem (ValorDesconto : PChar; Item : Word = 0) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_AplicarDescontoSobreItem (ValorDesconto : String; Item : Word = 0) : SmallInt; overload;
function SWEDA_CancelarItem (Item : Word = 0) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_ProcurarItem (Codigo : PChar; Quantidade : PChar = nil) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_ProcurarItem (Codigo : String; Quantidade : String = '') : SmallInt; overload;
function SWEDA_RegistrarPagamento (IndiceMeio : Word; Valor : PChar = nil; Texto : PChar = nil) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_RegistrarPagamento (IndiceMeio : Word; Valor : String; Texto : String = '') : SmallInt; overload;
function SWEDA_RegistrarPagamento (DenominacaoMeio : PChar; Valor : PChar = nil; Texto : PChar = nil) : SmallInt; overload;
function SWEDA_RegistrarPagamento (DenominacaoMeio : String; Valor : String = ''; Texto : String = '') : SmallInt; overload;
function SWEDA_AplicarAcrescimoSubtotal (ValorAcrescimo : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_AplicarAcrescimoSubtotal (ValorAcrescimo : String) : SmallInt; overload;
function SWEDA_AplicarDescontoSubtotal (ValorDesconto : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_AplicarDescontoSubtotal (ValorDesconto : String) : SmallInt; overload;
function SWEDA_TotalizarDocumento() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;

// d. Cancelamento e Estorno de Pagamento
function SWEDA_CancelarDocumento() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_EmitirEstornoPagamento (IndiceMeioEstornado : Word; ValorEstornado : PChar; IndiceMeioEfetivado : Word; ValorEfetivado : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_EmitirEstornoPagamento (IndiceMeioEstornado : Word; ValorEstornado : String; IndiceMeioEfetivado : Word; ValorEfetivado : String) : SmallInt; overload;
function SWEDA_EmitirEstornoPagamento (DenominacaoMeioEstornado : PChar; ValorEstornado : PChar; DenominacaoMeioEfetivado : PChar; ValorEfetivado : PChar) : SmallInt; overload;
function SWEDA_EmitirEstornoPagamento (DenominacaoMeioEstornado : String; ValorEstornado : String; DenominacaoMeioEfetivado : String; ValorEfetivado : String) : SmallInt; overload;

// e. Comprovante de Crédito ou Débito
function SWEDA_AbrirCCD (IndiceMeio : Word; ValorOperacao : PChar; Parcelas : Word = 1) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_AbrirCCD (IndiceMeio : Word; ValorOperacao : String; Parcelas : Word = 1) : SmallInt; overload;
function SWEDA_AbrirCCD (DenominacaoMeio : PChar; ValorOperacao : PChar; Parcelas : Word = 1) : SmallInt; overload;
function SWEDA_AbrirCCD (DenominacaoMeio : String; ValorOperacao : String; Parcelas : Word = 1) : SmallInt; overload;
function SWEDA_AbrirReimpressaoCCD() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_AbrirCCDEstorno(CDC : PChar = nil) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_AbrirCCDEstorno(CDC : String) : SmallInt; overload;
function SWEDA_AbrirReimpressaoCCDEstorno() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_ReimprimirDocumento() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_EmitirSegundaVia() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;

// f. Relatório Gerencial
function SWEDA_AbrirRelatorioGerencial (Titulo : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_AbrirRelatorioGerencial (Titulo : String) : SmallInt; overload;
function SWEDA_ImprimirCodigoBarras (TipoCodigo : Word; Codigo : PChar; Alinhamento : Word; Altura : Word; Magnitude : Word; PosicaoHRI : Word; FonteHRI : Word; MargemEsquerda : Word) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_ImprimirCodigoBarras (TipoCodigo : Word; Codigo : String; Alinhamento : Word; Altura : Word; Magnitude : Word; PosicaoHRI : Word; FonteHRI : Word; MargemEsquerda : Word) : SmallInt; overload;

// g. Impressão de texto não-fiscal
function SWEDA_ImprimirTextoNaoFiscal (Texto : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_ImprimirTextoNaoFiscal (Texto : String) : SmallInt; overload;
function SWEDA_ImprimirArquivoTexto (ArquivoOrigem : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_ImprimirArquivoTexto (ArquivoOrigem : String) : SmallInt; overload;

// h. Encerrar a emissão
function SWEDA_FecharDocumento(MensagemSuplementar : PChar; Opcoes : Word = 2) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_FecharDocumento(MensagemSuplementar : String; Opcoes : Word = 2) : SmallInt; overload;
function SWEDA_FecharDocumento(Opcoes : Word = 2) : SmallInt; overload;

// i. Leitura de Parâmetros
function SWEDA_EmitirLeituraParametros() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;

// j. Documentos Fiscais
function SWEDA_EmitirLeituraX() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_EmitirLeituraMemoriaFiscal (SelecaoInicial : PChar; SelecaoFinal : PChar; LeituraCompleta : Boolean = true) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_EmitirLeituraMemoriaFiscal (SelecaoInicial : String; SelecaoFinal : String; LeituraCompleta : Boolean = true) : SmallInt; overload;
procedure SWEDA_CancelarEmissaoLMF(); stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_ImprimirFitaDetalhe (SelecaoInicial : PChar; SelecaoFinal : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_ImprimirFitaDetalhe (SelecaoInicial : String; SelecaoFinal : String) : SmallInt; overload;

// k. Redução Z
function SWEDA_EmitirReducaoZ(Data : PChar = nil; Horario : PChar = nil; HorarioVerao : SmallInt = -1) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_EmitirReducaoZ(Data : String; Horario : String; HorarioVerao : SmallInt = -1) : SmallInt; overload;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 4. FUNÇÕES DE RELÓGIO, AUTENTICAÇÃO, CHEQUE, CMC7, GAVETA E OUTRAS

function SWEDA_AjustarRelogioTempoReal(Data : PChar; Horario : PChar; HorarioVerao : SmallInt = -1) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_AjustarRelogioTempoReal(Data : String; Horario : String; HorarioVerao : SmallInt = -1) : SmallInt; overload;
function SWEDA_HabilitarHorarioVerao() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_DesabilitarHorarioVerao() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_AtualizarDataHorario() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_PreencherCheque (Banco : PChar; Valor : PChar; Favorecido : PChar = nil; Municipio : PChar = nil; Data : PChar = nil; MoedaSingular : PChar = nil; MoedaPlural : PChar = nil; Rodape : PChar = nil; Verso : PChar = nil; Opcoes : Word = 0; Timeout : Integer = 0) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_PreencherCheque (Banco : String; Valor : String; Favorecido : String = ''; Municipio : String = ''; Data : String = ''; MoedaSingular : String = ''; MoedaPlural : String = ''; Rodape : String = ''; Verso : String = ''; Opcoes : Word = 0; Timeout : Integer = 0) : SmallInt; overload;
function SWEDA_CancelarPreenchimentoCheque() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_ProgramarLeiauteCheque (Leiaute : TIFSLeiauteCheque) : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_ZerarLeiautesCheque (CarregarDefaults : Boolean = true) : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_ReconhecimentoCaracteresMagneticos (Fonte : Word; Opcoes : Word; Timeout : Integer = 10000; Resultado : Pointer = nil; Extensao : Word = SizeOf (TMICR)) : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_CancelarMICR() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_Autenticar(Texto : PChar; Opcoes : Word = 0; Logotipo : Pointer = nil; TempoEspera : Integer = 10000) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_Autenticar(Texto : String; Opcoes : Word = 0; Logotipo : Pointer = nil; TempoEspera : Integer = 10000) : SmallInt; overload;
function SWEDA_AbrirGaveta() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 5. FUNÇÕES PARA PROGRAMAÇÃO DE PARÂMETROS DO ECF

// a. Função para programação dos parâmetros do ECF
function SWEDA_ProgramarParametrosECF (Parametros : Pointer; Opcoes : Word) : Boolean; stdcall; external DLL_SWEDA_CONNECT;

// b. Funções para criação, leitura e programação de parâmetros através do arquivo de configuração
function SWEDA_GravarArquivoConfiguracao(Parametros : Pointer; NomeArquivo : PChar = nil) : Boolean; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_GravarArquivoConfiguracao(Parametros : Pointer; NomeArquivo : String) : Boolean; overload;
function SWEDA_AtualizarArquivoConfiguracao() : Boolean; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_LerArquivoConfiguracao(NomeArquivo : PChar; Parametros : Pointer; Extensao : Word = SizeOf (TParametros)) : Boolean; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_LerArquivoConfiguracao(NomeArquivo : String; Parametros : Pointer; Extensao : Word = SizeOf (TParametros)) : Boolean; overload;
function SWEDA_CarregarArquivoConfiguracao(NomeArquivo : PChar; Opcoes : Word) : Boolean; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_CarregarArquivoConfiguracao(NomeArquivo : String; Opcoes : Word) : Boolean; overload;

// c. Funções para programação específica e inclusões
function SWEDA_ProgramarParametrosOperacionais(CasaAdicional : Boolean; DescontoISSQN : Boolean) : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_ProgramarParametrosCabecalhoRodape (Loja : PChar; Caixa : PChar; LegendaCNPJ : PChar = nil; LegendaIE : PChar = nil; LegendaIM : PChar = nil) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_ProgramarParametrosCabecalhoRodape (Loja : String; Caixa : String; LegendaCNPJ : String = ''; LegendaIE : String = ''; LegendaIM : String = '') : SmallInt; overload;
function SWEDA_ProgramarCliche(RazaoSocial : PChar; NomeFantasia : PChar; Endereco : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_ProgramarCliche(RazaoSocial : String; NomeFantasia : String; Endereco : String) : SmallInt; overload;
function SWEDA_ProgramarCliche(Cliche : TCliche) : SmallInt; overload;
function SWEDA_ProgramarAliquotas (Lista : Pointer) : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_InserirAliquota (Aliquota : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_InserirAliquota (Aliquota : String) : SmallInt; overload;
function SWEDA_ProgramarRelatoriosGerenciais (Lista : Pointer) : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_InserirRelatorioGerencial (Titulo : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_InserirRelatorioGerencial (Titulo : String) : SmallInt; overload;
function SWEDA_ProgramarMeiosPagamento (Lista : Pointer) : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_InserirMeioPagamento (Denominacao : PChar; Classificacao : Word = 0) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_InserirMeioPagamento (Denominacao : String; Classificacao : Word = 0) : SmallInt; overload;
function SWEDA_ProgramarOperacoesNF (Lista : Pointer) : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_InserirONF (Denominacao : PChar; Tipo : Word = Word ('+')) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_InserirONF (Denominacao : String; Tipo : Word = Word ('+')) : SmallInt; overload;
function SWEDA_ProgramarTotalizadoresNaoTributados(nF : Word; nI : Word; nN : Word; nFS : Word; nIS : Word; nNS : Word) : SmallInt; stdcall; external DLL_SWEDA_CONNECT;

function SWEDA_ImprimirLogotipoUsuario(Logotipo : Pointer = nil) : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_GravarLogotipoUsuario() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_ExcluirLogotipoUsuario() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 6. FUNÇÕES AUXILIARES

// a. Funções para gravação de leituras fiscais em arquivo
function SWEDA_GravarLeituraX(ArquivoSaida : PChar; Opcoes : Word = 0) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_GravarLeituraX(ArquivoSaida : String; Opcoes : Word = 0) : SmallInt; overload;
function SWEDA_GravarLeituraMemoriaFiscal (ArquivoSaida : PChar; SelecaoInicial : PChar; SelecaoFinal : PChar; Completa : Boolean = true; Opcoes : Word = 0) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_GravarLeituraMemoriaFiscal (ArquivoSaida : String; SelecaoInicial : String; SelecaoFinal : String; Completa : Boolean = true; Opcoes : Word = 0) : SmallInt; overload;
function SWEDA_GravarLeituraParametros(ArquivoSaida : PChar; Opcoes : Word = 0) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_GravarLeituraParametros(ArquivoSaida : String; Opcoes : Word = 0) : SmallInt; overload;
function SWEDA_GravarFitaDetalhe (ArquivoSaida : PChar; SelecaoInicial : PChar; SelecaoFinal : PChar; Opcoes : Word = 0) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_GravarFitaDetalhe (ArquivoSaida : String; SelecaoInicial : String; SelecaoFinal : String; Opcoes : Word = 0) : SmallInt; overload;

// b. Funções para captura de leituras fiscais on-line
function SWEDA_CapturarLeituraX(Opcoes : Word = 0; Buffer : Pointer = nil; BufferSize : Integer = 0) : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_CapturarLeituraMemoriaFiscal (SelecaoInicial : PChar; SelecaoFinal : PChar = nil; Completa : Boolean = true; Opcoes : Word = 0; Buffer : Pointer = nil; BufferSize : Integer = 0) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_CapturarLeituraMemoriaFiscal (SelecaoInicial : String; SelecaoFinal : String = ''; Completa : Boolean = true; Opcoes : Word = 0; Buffer : Pointer = nil; BufferSize : Integer = 0) : SmallInt; overload;
function SWEDA_CapturarLeituraParametros(Opcoes : Word = 0; Buffer : Pointer = nil; BufferSize : Integer = 0) : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_CapturarFitaDetalhe (SelecaoInicial : PChar; SelecaoFinal : PChar = nil; Opcoes : Word = 0; Buffer : Pointer = nil; BufferSize : Integer = 0) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_CapturarFitaDetalhe (SelecaoInicial : String; SelecaoFinal : String = ''; Opcoes : Word = 0; Buffer : Pointer = nil; BufferSize : Integer = 0) : SmallInt; overload;
procedure SWEDA_InterromperCaptura(); stdcall; external DLL_SWEDA_CONNECT;

// 7. FUNÇÕES DIVERSAS
function SWEDA_ObterConsumoMFD() : Integer; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_ObterPercentualConsumoMFD() : Integer; stdcall; external DLL_SWEDA_CONNECT;

function SWEDA_AcionarGuilhotina() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_AvancarPapelBobina() : SmallInt; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_ECFLigado() : Boolean; stdcall; external DLL_SWEDA_CONNECT;
function SWEDA_ExecutarComandoFiscal (Comando : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_ExecutarComandoFiscal (Comando : String) : SmallInt; overload;
function SWEDA_ObterStatusECF (Selecao : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_ObterStatusECF (Selecao : String) : SmallInt; overload;
function SWEDA_ProcurarMeioPagamento (Denominacao : PChar) : SmallInt; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_ProcurarMeioPagamento (Denominacao : AnsiString) : SmallInt; overload;

// Logotipos
function SWEDA_AbrirArquivoLogotipoAutenticacao (Arquivo : PChar; LogotipoAutenticacao : Pointer = nil; Extensao : Word = SizeOf (TLogotipoAutenticacao)) : Boolean; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_AbrirArquivoLogotipoAutenticacao (Arquivo : String; LogotipoAutenticacao : Pointer = nil; Extensao : Word = SizeOf (TLogotipoAutenticacao)) : Boolean; overload;
function SWEDA_AbrirArquivoLogotipoUsuario (Arquivo : PChar; LogotipoUsuario : Pointer = nil; Extensao : Word = SizeOf (TLogotipoUsuario)) : Boolean; stdcall; external DLL_SWEDA_CONNECT; overload;
function SWEDA_AbrirArquivoLogotipoUsuario (Arquivo : String; LogotipoUsuario : Pointer = nil; Extensao : Word = SizeOf (TLogotipoUsuario)) : Boolean; overload;





implementation

// funções sobrecarregadas (overloaded)

function SWEDA_ProcurarMeioPagamento (Denominacao : AnsiString) : SmallInt; overload;
begin
   Result := SWEDA_ProcurarMeioPagamento (PChar (Denominacao));
end;

function SWEDA_ConectarAplicativo(Identificacao : String) : SmallInt; overload;
begin
   Result := SWEDA_ConectarAplicativo(PChar (Identificacao));
end;

function SWEDA_IdentificarOperadorCaixa(Identificacao : String) : SmallInt; overload;
begin
   Result := SWEDA_IdentificarOperadorCaixa(PChar (Identificacao));
end;

function SWEDA_RegistrarItem (Quantidade : String; Codigo : String; ValorUnitario : String; UnidadeMedida : String; SituacaoTributaria : String; Descricao : String) : SmallInt; overload;
begin
   Result := SWEDA_RegistrarItem (PChar (Quantidade), PChar (Codigo), PChar (ValorUnitario), PChar (UnidadeMedida), PChar (SituacaoTributaria), PChar (Descricao));
end;

function SWEDA_RegistrarOperacaoNaoFiscal(Denominacao : String; Total : String) : SmallInt; overload;
begin
   Result := SWEDA_RegistrarOperacaoNaoFiscal(PChar (Denominacao), Pchar (Total));
end;

function SWEDA_RegistrarConsumidor(CNPJ : String = ''; Nome : String = ''; Endereco : String = ''; Rodape : Boolean = false) : SmallInt; overload;
begin
   Result := SWEDA_RegistrarConsumidor(PChar (CNPJ), PChar (Nome), PChar (Endereco), Rodape);
end;

function SWEDA_AplicarAcrescimoSobreItem (ValorAcrescimo : String; Item : Word = 0) : SmallInt; overload;
begin
   Result := SWEDA_AplicarAcrescimoSobreItem (PChar (ValorAcrescimo), Item);
end;

function SWEDA_AplicarDescontoSobreItem (ValorDesconto : String; Item : Word = 0) : SmallInt; overload;
begin
   Result := SWEDA_AplicarDescontoSobreItem (PChar (ValorDesconto), Item);
end;

function SWEDA_ProcurarItem (Codigo : String; Quantidade : String = '') : SmallInt; overload;
begin
   Result := SWEDA_ProcurarItem (PChar (Codigo), PChar (Quantidade))
end;

function SWEDA_RegistrarPagamento (IndiceMeio : Word; Valor : String; Texto : String = '') : SmallInt; overload;
begin
   Result := SWEDA_RegistrarPagamento (IndiceMeio, PChar (Valor), PChar (Texto))
end;

function SWEDA_RegistrarPagamento (DenominacaoMeio : PChar; Valor : PChar = nil; Texto : PChar = nil) : SmallInt; overload;
begin
   Result := SWEDA_RegistrarPagamento (SWEDA_ProcurarMeioPagamento (DenominacaoMeio), Valor, Texto);
end;

function SWEDA_RegistrarPagamento (DenominacaoMeio : String; Valor : String = ''; Texto : String = '') : SmallInt; overload;
var
PValor : PChar;
begin
   if (Valor = '') then PValor := PChar (Valor) else PValor := nil;
   Result := SWEDA_RegistrarPagamento (PChar (DenominacaoMeio), PValor, PChar (Texto));
end;

function SWEDA_AplicarAcrescimoSubtotal (ValorAcrescimo : String) : SmallInt; overload;
begin
   Result := SWEDA_AplicarAcrescimoSubtotal (PChar (ValorAcrescimo));
end;

function SWEDA_AplicarDescontoSubtotal (ValorDesconto : String) : SmallInt; overload;
begin
   Result := SWEDA_AplicarDescontoSubtotal (PChar (ValorDesconto));
end;

function SWEDA_EmitirEstornoPagamento (IndiceMeioEstornado : Word; ValorEstornado : String; IndiceMeioEfetivado : Word; ValorEfetivado : String) : SmallInt; overload;
begin
   Result := SWEDA_EmitirEstornoPagamento (IndiceMeioEstornado, PChar (ValorEstornado), IndiceMeioEfetivado, PChar (ValorEfetivado));
end;

function SWEDA_EmitirEstornoPagamento (DenominacaoMeioEstornado : PChar; ValorEstornado : PChar; DenominacaoMeioEfetivado : PChar; ValorEfetivado : PChar) : SmallInt; overload;
begin
   Result := SWEDA_EmitirEstornoPagamento (SWEDA_ProcurarMeioPagamento (DenominacaoMeioEstornado), ValorEstornado, SWEDA_ProcurarMeioPagamento (DenominacaoMeioEfetivado), ValorEfetivado);
end;

function SWEDA_EmitirEstornoPagamento (DenominacaoMeioEstornado : String; ValorEstornado : String; DenominacaoMeioEfetivado : String; ValorEfetivado : String) : SmallInt; overload;
begin
   Result := SWEDA_EmitirEstornoPagamento (PChar (DenominacaoMeioEstornado), PChar (ValorEstornado), PChar (DenominacaoMeioEfetivado), PChar (ValorEfetivado));
end;


function SWEDA_AbrirCCD (IndiceMeio : Word; ValorOperacao : String; Parcelas : Word = 1) : SmallInt; overload;
begin
   Result := SWEDA_AbrirCCD (IndiceMeio, PChar (ValorOperacao), Parcelas);
end;

function SWEDA_AbrirCCD (DenominacaoMeio : PChar; ValorOperacao : PChar; Parcelas : Word = 1) : SmallInt; overload;
begin
   Result := SWEDA_AbrirCCD (SWEDA_ProcurarMeioPagamento (DenominacaoMeio), ValorOperacao, Parcelas);
end;

function SWEDA_AbrirCCD (DenominacaoMeio : String; ValorOperacao : String; Parcelas : Word = 1) : SmallInt; overload;
begin
   Result := SWEDA_AbrirCCD (PChar (DenominacaoMeio), PChar (ValorOperacao), Parcelas);
end;

function SWEDA_AbrirCCDEstorno(CDC : String) : SmallInt; overload;
begin
   Result := SWEDA_AbrirCCDEstorno(PChar (CDC));
end;

function SWEDA_AbrirRelatorioGerencial (Titulo : String) : SmallInt; overload;
begin
   Result := SWEDA_AbrirRelatorioGerencial (PChar (Titulo));
end;

function SWEDA_ImprimirCodigoBarras (TipoCodigo : Word; Codigo : String; Alinhamento : Word; Altura : Word; Magnitude : Word; PosicaoHRI : Word; FonteHRI : Word; MargemEsquerda : Word) : SmallInt; overload;
begin
   Result := SWEDA_ImprimirCodigoBarras (TipoCodigo, PChar (Codigo), Alinhamento, Altura, Magnitude, PosicaoHRI, FonteHRI, MargemEsquerda);
end;

function SWEDA_ImprimirTextoNaoFiscal (Texto : String) : SmallInt; overload;
begin
   Result := SWEDA_ImprimirTextoNaoFiscal (PChar (Texto));
end;

function SWEDA_ImprimirArquivoTexto (ArquivoOrigem : String) : SmallInt; overload;
begin
   Result := SWEDA_ImprimirArquivoTexto (PChar (ArquivoOrigem));
end;

function SWEDA_FecharDocumento(MensagemSuplementar : String; Opcoes : Word = 2) : SmallInt; overload;
begin
   Result := SWEDA_FecharDocumento(PChar (MensagemSuplementar), Opcoes);
end;

function SWEDA_FecharDocumento(Opcoes : Word = 2) : SmallInt; overload;
begin
   Result := SWEDA_FecharDocumento(PChar (''), Opcoes);
end;

function SWEDA_EmitirLeituraMemoriaFiscal (SelecaoInicial : String; SelecaoFinal : String; LeituraCompleta : Boolean = true) : SmallInt; overload;
begin
   Result := SWEDA_EmitirLeituraMemoriaFiscal (PChar (SelecaoInicial), PChar (SelecaoFinal), LeituraCompleta);
end;

function SWEDA_ImprimirFitaDetalhe (SelecaoInicial : String; SelecaoFinal : String) : SmallInt; overload;
begin
   Result := SWEDA_ImprimirFitaDetalhe (PChar (SelecaoInicial), PChar (SelecaoFinal));
end;

function SWEDA_EmitirReducaoZ(Data : String; Horario : String; HorarioVerao : SmallInt = -1) : SmallInt; overload;
begin
   Result := SWEDA_EmitirReducaoZ(PChar (Data), PChar (Horario), HorarioVerao);
end;

function SWEDA_AjustarRelogioTempoReal(Data : String; Horario : String; HorarioVerao : SmallInt = -1) : SmallInt; overload;
begin
   Result := SWEDA_AjustarRelogioTempoReal(PChar (Data), PChar (Horario), HorarioVerao);
end;

function SWEDA_PreencherCheque (Banco : String; Valor : String; Favorecido : String = ''; Municipio : String = ''; Data : String = ''; MoedaSingular : String = ''; MoedaPlural : String = ''; Rodape : String = ''; Verso : String = ''; Opcoes : Word = 0; Timeout : Integer = 0) : SmallInt; overload;
begin
   Result := SWEDA_PreencherCheque (PChar (Banco), PChar (Valor), PChar (Favorecido), PChar (Municipio), PChar (Data), PChar (MoedaSingular), PChar (MoedaPlural), PChar (Rodape), PChar (Verso), Opcoes, Timeout);
end;

function SWEDA_Autenticar(Texto : String; Opcoes : Word = 0; Logotipo : Pointer = nil; TempoEspera : Integer = 10000) : SmallInt; overload;
begin
   Result := SWEDA_Autenticar(PChar (Texto), Opcoes, Logotipo, TempoEspera);
end;

function SWEDA_GravarArquivoConfiguracao(Parametros : Pointer; NomeArquivo : String) : Boolean; overload;
begin
   Result := SWEDA_GravarArquivoConfiguracao(Parametros, PChar (NomeArquivo));
end;

function SWEDA_LerArquivoConfiguracao(NomeArquivo : String; Parametros : Pointer; Extensao : Word = SizeOf (TParametros)) : Boolean; overload;
begin
   Result := SWEDA_LerArquivoConfiguracao(PChar (NomeArquivo), Parametros, Extensao);
end;

function SWEDA_CarregarArquivoConfiguracao(NomeArquivo : String; Opcoes : Word) : Boolean; overload;
begin
   Result := SWEDA_CarregarArquivoConfiguracao(PChar (NomeArquivo), Opcoes);
end;

function SWEDA_ProgramarParametrosCabecalhoRodape (Loja : String; Caixa : String; LegendaCNPJ : String = ''; LegendaIE : String = ''; LegendaIM : String = '') : SmallInt; overload;
begin
   Result := SWEDA_ProgramarParametrosCabecalhoRodape (PChar (Loja), PChar (Caixa), PChar (LegendaCNPJ), PChar (LegendaIE), PChar (LegendaIM));
end;

function SWEDA_ProgramarCliche(RazaoSocial : String; NomeFantasia : String; Endereco : String) : SmallInt; overload;
begin
   Result := SWEDA_ProgramarCliche(PChar (RazaoSocial), PChar (NomeFantasia), PChar (Endereco));
end;

function SWEDA_ProgramarCliche(Cliche : TCliche) : SmallInt; overload;
begin
   Result := SWEDA_ProgramarCliche(Cliche.RazaoSocial, Cliche.NomeFantasia, Cliche.Endereco);
end;

function SWEDA_InserirAliquota (Aliquota : String) : SmallInt; overload;
begin
   Result := SWEDA_InserirAliquota (PChar (Aliquota));
end;

function SWEDA_InserirRelatorioGerencial (Titulo : String) : SmallInt; overload;
begin
   Result := SWEDA_InserirRelatorioGerencial (PChar (Titulo));
end;

function SWEDA_InserirMeioPagamento (Denominacao : String; Classificacao : Word = 0) : SmallInt; overload;
begin
   Result := SWEDA_InserirMeioPagamento (Pchar (Denominacao), Classificacao);
end;

function SWEDA_InserirONF (Denominacao : String; Tipo : Word = Word ('+')) : SmallInt; overload;
begin
   Result := SWEDA_InserirONF (PChar (Denominacao), Tipo);

end;

function SWEDA_GravarLeituraX(ArquivoSaida : String; Opcoes : Word = 0) : SmallInt; overload;
begin
   Result := SWEDA_GravarLeituraX(PChar (ArquivoSaida), Opcoes);
end;

function SWEDA_GravarLeituraMemoriaFiscal (ArquivoSaida : String; SelecaoInicial : String; SelecaoFinal : String; Completa : Boolean = true; Opcoes : Word = 0) : SmallInt; overload;
begin
   Result := SWEDA_GravarLeituraMemoriaFiscal (PChar (ArquivoSaida), PChar (SelecaoInicial), PChar (SelecaoFinal), Completa, Opcoes);
end;

function SWEDA_GravarLeituraParametros(ArquivoSaida : String; Opcoes : Word = 0) : SmallInt; overload;
begin
   Result := SWEDA_GravarLeituraParametros(PChar (ArquivoSaida), Opcoes);
end;

function SWEDA_GravarFitaDetalhe (ArquivoSaida : String; SelecaoInicial : String; SelecaoFinal : String; Opcoes : Word = 0) : SmallInt; overload;
begin
   Result := SWEDA_GravarFitaDetalhe (PChar (ArquivoSaida), PChar (SelecaoInicial), PChar (SelecaoFinal), Opcoes);
end;

function SWEDA_CapturarLeituraMemoriaFiscal (SelecaoInicial : String; SelecaoFinal : String = ''; Completa : Boolean = true; Opcoes : Word = 0; Buffer : Pointer = nil; BufferSize : Integer = 0) : SmallInt; overload;
begin
   Result := SWEDA_CapturarLeituraMemoriaFiscal (PChar (SelecaoInicial), PChar (SelecaoFinal), Completa, Opcoes, Buffer, BufferSize);
end;

function SWEDA_CapturarFitaDetalhe (SelecaoInicial : String; SelecaoFinal : String = ''; Opcoes : Word = 0; Buffer : Pointer = nil; BufferSize : Integer = 0) : SmallInt; overload;
begin
   Result := SWEDA_CapturarFitaDetalhe (PChar (SelecaoInicial), PChar (SelecaoFinal), Opcoes, Buffer, BufferSize);
end;

function SWEDA_ExecutarComandoFiscal (Comando : String) : SmallInt; overload;
begin
   Result := SWEDA_ExecutarComandoFiscal (PChar (Comando));
end;

function SWEDA_ObterStatusECF (Selecao : String) : SmallInt; overload;
begin
   Result := SWEDA_ObterStatusECF (PChar (Selecao));
end;

function SWEDA_AbrirArquivoLogotipoAutenticacao (Arquivo : String; LogotipoAutenticacao : Pointer = nil; Extensao : Word = SizeOf (TLogotipoAutenticacao)) : Boolean; overload;
begin
   Result := SWEDA_AbrirArquivoLogotipoAutenticacao (PChar (Arquivo), LogotipoAutenticacao, Extensao);
end;

function SWEDA_AbrirArquivoLogotipoUsuario (Arquivo : String; LogotipoUsuario : Pointer = nil; Extensao : Word = SizeOf (TLogotipoUsuario)) : Boolean; overload;
begin
   Result := SWEDA_AbrirArquivoLogotipoUsuario (PChar (Arquivo), LogotipoUsuario, Extensao);
end;


end.



